import { NextRequest, NextResponse } from 'next/server';
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

export async function GET(request: NextRequest) {
  try {
    const url = new URL(request.url || 'http://localhost');
    const tokenId = url.searchParams.get('tokenId');
    const after = url.searchParams.get('after');

    if (!tokenId) {
      return NextResponse.json({ error: '缺少tokenId参数' }, { status: 400 });
    }

    // 获取代币信息以获取当前价格
    const token = await prisma.memeToken.findUnique({
      where: { id: tokenId }
    });

    if (!token) {
      return NextResponse.json({ error: '代币不存在' }, { status: 404 });
    }

    // 总是返回一个当前时间的RSI数据点（基于实时计算）
    const now = new Date();
    
    // 获取最近30条1分钟历史数据用于RSI计算（确保有足够的数据）
    const historicalData = await prisma.priceData.findMany({
      where: {
        tokenId: tokenId
      },
      orderBy: {
        timestamp: 'desc'
      },
      take: 30,
      select: {
        price: true,
        timestamp: true
      }
    });

    console.log(`RSI Latest API: tokenId=${tokenId}, 历史数据=${historicalData.length}条`);

    if (historicalData.length < 14) {
      return NextResponse.json([]);
    }

    // 获取当前实时价格
    let currentPrice = historicalData[0].price;
    
    try {
      // 调用当前价格API获取实时价格
      const priceResponse = await fetch(`${process.env.NEXTAUTH_URL || 'http://localhost:3000'}/api/current-price?contractAddress=${token.contractAddress}&chain=${token.chain}`);
      if (priceResponse.ok) {
        const priceData = await priceResponse.json();
        if (priceData.price) {
          currentPrice = priceData.price;
          console.log(`获取到实时价格: $${currentPrice}`);
        }
      }
    } catch (error) {
      console.log('获取实时价格失败，使用数据库价格:', error);
      // 使用数据库中的最新价格作为fallback
    }

    // 构建用于RSI计算的价格数组
    // 使用最近14个1分钟数据点 + 当前实时价格
    const historicalPrices = historicalData.reverse().slice(-14).map(h => h.price);
    const allPrices = [...historicalPrices, currentPrice];
    
    // 计算当前RSI
    const currentRSI = calculateRSI(allPrices);

    // 返回当前时间点的RSI数据
    const currentDataPoint = {
      timestamp: now.toISOString(),
      price: currentPrice,
      rsi: currentRSI
    };

    console.log(`RSI Latest: 当前价格=${currentPrice}, RSI=${currentRSI}`);

    // 返回当前实时计算的RSI数据点
    return NextResponse.json([currentDataPoint]);

  } catch (error) {
    console.error('获取最新RSI数据失败:', error);
    return NextResponse.json(
      { error: '获取最新RSI数据失败' },
      { status: 500 }
    );
  }
}

// 标准RSI计算函数（使用Wilder's平滑方法）
function calculateRSI(prices: number[], period: number = 14): number {
  if (prices.length < period + 1) {
    return 50; // 数据不足时返回中性值
  }

  const changes: number[] = [];
  
  // 计算价格变化
  for (let i = 1; i < prices.length; i++) {
    changes.push(prices[i] - prices[i - 1]);
  }

  if (changes.length < period) {
    return 50;
  }

  // 计算初始的平均收益和损失（前14个周期使用SMA）
  let avgGain = 0;
  let avgLoss = 0;
  
  for (let i = 0; i < period; i++) {
    if (changes[i] > 0) {
      avgGain += changes[i];
    } else {
      avgLoss += Math.abs(changes[i]);
    }
  }
  
  avgGain /= period;
  avgLoss /= period;

  // 使用Wilder's平滑方法计算后续的平均值
  for (let i = period; i < changes.length; i++) {
    const gain = changes[i] > 0 ? changes[i] : 0;
    const loss = changes[i] < 0 ? Math.abs(changes[i]) : 0;
    
    // Wilder's平滑公式：新平均 = (旧平均 * (期间-1) + 新值) / 期间
    avgGain = (avgGain * (period - 1) + gain) / period;
    avgLoss = (avgLoss * (period - 1) + loss) / period;
  }

  // 处理边界情况
  if (avgGain === 0 && avgLoss === 0) {
    return 50;
  }

  if (avgLoss === 0) {
    return 100;
  }

  const rs = avgGain / avgLoss;
  const rsi = 100 - (100 / (1 + rs));

  console.log(`RSI计算详情: 平均收益=${avgGain.toFixed(6)}, 平均损失=${avgLoss.toFixed(6)}, RS=${rs.toFixed(4)}, RSI=${rsi.toFixed(2)}`);

  return Math.round(rsi * 100) / 100;
}
